package top.jacktgq.closure

/**
 @Author CandyWall
 @Date 2021/4/27--14:40
 @Description 闭包进阶内容
 */
println "闭包被定义在不同的位置，结果this，owner和delegate三个关键字指向的对象也不同"
// 脚本文件中的闭包
// 闭包的三个重要变量
def scriptClosure = {
    println "脚本文件中闭包的this: ${this}" // 代表闭包定义处的类
    println "脚本文件中闭包的owner: ${owner}"   // 代表比表定义处的类或者对象
    println "脚本文件中闭包的delegate: ${delegate}" // 代表任意对象，默认值是owner所指向的对象
}

scriptClosure.call()

// 类中的闭包
// 定义了一个Person类
class Person1 {
    def static classClosure = {
        println "类中静态属性闭包的this: ${this}" // 代表闭包定义处的类
        println "类中静态属性闭包的owner: ${owner}"   // 代表比表定义处的类或者对象
        println "类中静态属性闭包的delegate: ${delegate}" // 代表任意对象，默认值是owner所指向的对象
    }

    def static say() {
        def methodClosure = {
            println "类中的静态方法中闭包的this: ${this}" // 代表闭包定义处的类
            println "类中的静态方法中闭包的owner: ${owner}"   // 代表比表定义处的类或者对象
            println "类中的静态方法中闭包delegate: ${delegate}" // 代表任意对象，默认值是owner所指向的对象
        }

        methodClosure.call()
    }
}

Person1.classClosure.call()
Person1.say()

class Person2 {
    def classClosure = {
        println "类中的属性闭包的this: ${this}" // 代表闭包定义处的类
        println "类中的属性闭包的owner: ${owner}"   // 代表比表定义处的类或者对象
        println "类中的属性闭包的delegate: ${delegate}" // 代表任意对象，默认值是owner所指向的对象
    }

    def say() {
        def methodClosure = {
            println "类的方法中闭包的this: ${this}" // 代表闭包定义处的类
            println "类的方法中闭包的owner: ${owner}"   // 代表比表定义处的类或者对象
            println "类的方法中闭包delegate: ${delegate}" // 代表任意对象，默认值是owner所指向的对象
        }

        methodClosure.call()
    }
}

def p = new Person2()
p.classClosure.call()
p.say()

// 闭包中定义闭包
def nestClosure1 = {

    def innerClosure = {
        //println "闭包中的闭包的this: ${this}" // 代表闭包定义处的类
        //println "闭包中的闭包的owner: ${owner}"   // 代表比表定义处的类或者对象
        //println "闭包中的闭包的delegate: ${delegate}" // 代表任意对象，默认值是owner所指向的对象
        // 使用双引号字符串占位符会出现栈溢出的错误，所以改成下面的写法
        println "1闭包中的闭包的this: " + this // 代表闭包定义处的类
        println "1闭包中的闭包的owner: " + owner   // 代表比表定义处的类或者对象
        println "1闭包中的闭包的delegate: " + delegate // 代表任意对象，默认值是owner所指向的对象
    }
    innerClosure.call()
}

nestClosure1.call()

// 修改deletegate的指向的对象
def nestClosure2 = {

    def innerClosure = {
        println "2闭包中的闭包的this: " + this // 代表闭包定义处的类
        println "2闭包中的闭包的owner: " + owner   // 代表比表定义处的类或者对象
        println "2闭包中的闭包的delegate: " + delegate // 代表任意对象，默认值是owner所指向的对象
    }
    innerClosure.delegate = p
    innerClosure.call()
}

nestClosure2.call()

println "闭包的委托策略================================"

class Student {
    String name
    int age
    def printClosure = {
        "我的名字是：${name}，年龄：${age}"
    }

    String toString() {
        printClosure.call()
    }
}

class Teacher {
    String name
    int age1
}

def student = new Student(name: "胖重", age: 33)
def teacher = new Teacher(name: "吉良吉影", age1: 17)
student.printClosure.delegate = teacher
student.printClosure.resolveStrategy = groovy.lang.Closure.DELEGATE_FIRST
// student.printClosure.resolveStrategy = groovy.lang.Closure.DELEGATE_ONLY
println student.toString()